package acom.teamcenter.tc.kernel.icctstubs;

import com.teamcenter.soa.client.Connection;
import com.teamcenter.soa.client.ResponseExceptionHandler;
import com.teamcenter.soa.client.SoaRuntimeException;
import com.teamcenter.soa.internal.client.RestSender;
import com.teamcenter.tc.kernel.icctstubs.BooleanHolder;
import com.teamcenter.tc.kernel.icctstubs.DoubleHolder;
import com.teamcenter.tc.kernel.icctstubs.ICCT;
import com.teamcenter.tc.kernel.icctstubs.ICCTException;
import com.teamcenter.tc.kernel.icctstubs.InterfaceClientSession;
import com.teamcenter.tc.kernel.icctstubs.InterfaceServiceGateway;
import com.teamcenter.tc.kernel.icctstubs.ObjectReference;
import com.teamcenter.tc.kernel.icctstubs.TcUtility;
import com.teamcenter.tc.kernel.icctstubs.byteSeq_tHolder;
import com.teamcenter.tc.kernel.icctstubs.longSeqValue_uHolder;
import com.teamcenter.tc.kernel.icctstubs.longSeq_tHolder;
import com.teamcenter.tc.kernel.icctstubs.stringSeqValue_uHolder;
import com.teamcenter.tc.kernel.icctstubs.stringSeq_tHolder;
import com.teamcenter.tc.kernel.icctstubs.stringValueSeq_tHolder;
import com.teamcenter.tc.kernel.icctstubs.stringValue_u;
import com.teamcenter.tc.kernel.icctstubs.stringValue_uHolder;
import com.teamcenter.tc.kernel.icctstubs.uidSeqValue_uHolder;
import com.teamcenter.tc.kernel.icctstubs.uidSeq_tHolder;
import com.teamcenter.tc.kernel.icctstubs.uidValueSeq_tHolder;
import com.teamcenter.tc.kernel.icctstubs.uidValue_u;
import com.teamcenter.tc.kernel.icctstubs.uidValue_uHolder;
import com.ugsplm.tc.codegen.parser.newreqresp.*;


/** 
 * ***********************************************************
 * *                                                         *
 * *      THE FOLLOWING SOURCE FILE HAS BEEN AUTOMATICALLY   *
 * *      GENERATED.  ANY HAND CRAFTED CHANGES WILL BE LOST! *
 * *                                                         *
 * ***********************************************************
 * 
 */

public class ICCTBOMLine extends ICCT implements ObjectReference {
  String service_name;

  String object_id;

  static ObjectFactory objFactory;


  public ICCTBOMLine(InterfaceClientSession sess) {
    super(sess);
    service_name = new String("ICCTBOMLine");
    objFactory = new ObjectFactory();
  }

  public void object_id(String objId) {
    object_id = objId;
  }

  public String object_id() {
    return object_id;
  }

  public void service_name(String svcName) {
    service_name = svcName;
  }

  public String service_name() {
    return service_name;
  }

  public void assignAsChild(byte[] bomline, byte[] sourceLine, stringValue_u occType, byteSeq_tHolder newChildLine, byteSeq_tHolder newChildLineType) throws Exception {
    final String TcMethodName = "assignAsChild";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("assignAsChild");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomline",bomline));
    tcreq.getArgs().add(TcUtility.createArg("sourceLine",sourceLine));
    tcreq.getArgs().add(TcUtility.createArg("occType",occType));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("newChildLine"))
        {
          newChildLine.value = TcUtility.queryArg((ArgType)respArgs.get(ii), newChildLine.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("newChildLineType"))
        {
          newChildLineType.value = TcUtility.queryArg((ArgType)respArgs.get(ii), newChildLineType.value);
        }
      }
    }
  }

  public void replace(byte[] bomline, uidValue_u item, uidValue_u rev, uidValue_u bv) throws Exception {
    final String TcMethodName = "replace";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("replace");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomline",bomline));
    tcreq.getArgs().add(TcUtility.createArg("item",item));
    tcreq.getArgs().add(TcUtility.createArg("rev",rev));
    tcreq.getArgs().add(TcUtility.createArg("bv",bv));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
      }
    }
  }

  public void replaceGDE(byte[] gdeline, uidValue_u gde) throws Exception {
    final String TcMethodName = "replaceGDE";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("replaceGDE");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("gdeline",gdeline));
    tcreq.getArgs().add(TcUtility.createArg("gde",gde));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
      }
    }
  }

  public void add(byte[] bomline, uidValue_u item, uidValue_u rev, uidValue_u bv, boolean asSubstitute, stringValue_u occType, byteSeq_tHolder newLine, byteSeq_tHolder type) throws Exception {
    final String TcMethodName = "add";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("add");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomline",bomline));
    tcreq.getArgs().add(TcUtility.createArg("item",item));
    tcreq.getArgs().add(TcUtility.createArg("rev",rev));
    tcreq.getArgs().add(TcUtility.createArg("bv",bv));
    tcreq.getArgs().add(TcUtility.createArg("asSubstitute",asSubstitute));
    tcreq.getArgs().add(TcUtility.createArg("occType",occType));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("newLine"))
        {
          newLine.value = TcUtility.queryArg((ArgType)respArgs.get(ii), newLine.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("type"))
        {
          type.value = TcUtility.queryArg((ArgType)respArgs.get(ii), type.value);
        }
      }
    }
  }

  public void addline(byte[] bomline, byte[] childLine, boolean asSubstitute, stringValue_u occType, byteSeq_tHolder newLine, byteSeq_tHolder type, boolean propaXform) throws Exception {
    final String TcMethodName = "addline";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("addline");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomline",bomline));
    tcreq.getArgs().add(TcUtility.createArg("childLine",childLine));
    tcreq.getArgs().add(TcUtility.createArg("asSubstitute",asSubstitute));
    tcreq.getArgs().add(TcUtility.createArg("occType",occType));
    tcreq.getArgs().add(TcUtility.createArg("propaXform",propaXform));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("newLine"))
        {
          newLine.value = TcUtility.queryArg((ArgType)respArgs.get(ii), newLine.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("type"))
        {
          type.value = TcUtility.queryArg((ArgType)respArgs.get(ii), type.value);
        }
      }
    }
  }

  public void addGDE(byte[] bomline, uidValue_u aGDE, stringValue_u occType, byteSeq_tHolder newLine, byteSeq_tHolder typeUid) throws Exception {
    final String TcMethodName = "addGDE";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("addGDE");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomline",bomline));
    tcreq.getArgs().add(TcUtility.createArg("aGDE",aGDE));
    tcreq.getArgs().add(TcUtility.createArg("occType",occType));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("newLine"))
        {
          newLine.value = TcUtility.queryArg((ArgType)respArgs.get(ii), newLine.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("typeUid"))
        {
          typeUid.value = TcUtility.queryArg((ArgType)respArgs.get(ii), typeUid.value);
        }
      }
    }
  }

  public void addGDELine(byte[] bomline, uidValue_u aGDELine, stringValue_u occType, byteSeq_tHolder newLine, byteSeq_tHolder typeUid, boolean propaXform) throws Exception {
    final String TcMethodName = "addGDELine";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("addGDELine");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomline",bomline));
    tcreq.getArgs().add(TcUtility.createArg("aGDELine",aGDELine));
    tcreq.getArgs().add(TcUtility.createArg("occType",occType));
    tcreq.getArgs().add(TcUtility.createArg("propaXform",propaXform));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("newLine"))
        {
          newLine.value = TcUtility.queryArg((ArgType)respArgs.get(ii), newLine.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("typeUid"))
        {
          typeUid.value = TcUtility.queryArg((ArgType)respArgs.get(ii), typeUid.value);
        }
      }
    }
  }

  public void addPredecessor(byte[] bomline, byte[] predBomline) throws Exception {
    final String TcMethodName = "addPredecessor";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("addPredecessor");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomline",bomline));
    tcreq.getArgs().add(TcUtility.createArg("predBomline",predBomline));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
      }
    }
  }

  public void removePredecessor(byte[] bomline, byte[] predBomline) throws Exception {
    final String TcMethodName = "removePredecessor";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("removePredecessor");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomline",bomline));
    tcreq.getArgs().add(TcUtility.createArg("predBomline",predBomline));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
      }
    }
  }

  public void generateXML(byte[] bomLine, byte[] publishRulesKey, byteSeq_tHolder fileLocation) throws Exception {
    final String TcMethodName = "generateXML";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("generateXML");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomLine",bomLine));
    tcreq.getArgs().add(TcUtility.createArg("publishRulesKey",publishRulesKey));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("fileLocation"))
        {
          fileLocation.value = TcUtility.queryArg((ArgType)respArgs.get(ii), fileLocation.value);
        }
      }
    }
  }

  public void removeAppearance(byte[] bomline, byte[] appearance, boolean asRequired) throws Exception {
    final String TcMethodName = "removeAppearance";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("removeAppearance");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomline",bomline));
    tcreq.getArgs().add(TcUtility.createArg("appearance",appearance));
    tcreq.getArgs().add(TcUtility.createArg("asRequired",asRequired));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
      }
    }
  }

  public void linkToAppearance(byte[] bomline, byte[] appline, boolean asRequired) throws Exception {
    final String TcMethodName = "linkToAppearance";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("linkToAppearance");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomline",bomline));
    tcreq.getArgs().add(TcUtility.createArg("appline",appline));
    tcreq.getArgs().add(TcUtility.createArg("asRequired",asRequired));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
      }
    }
  }

  public void askLinkedAppearance(byte[] bomline, boolean getRequired, uidSeq_tHolder appearances) throws Exception {
    final String TcMethodName = "askLinkedAppearance";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("askLinkedAppearance");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomline",bomline));
    tcreq.getArgs().add(TcUtility.createArg("getRequired",getRequired));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("appearances"))
        {
          appearances.value = TcUtility.queryArg((ArgType)respArgs.get(ii), appearances.value);
        }
      }
    }
  }

  public void askAppearanceLinks(byte[] bomline, stringValue_u relationType, uidSeq_tHolder linkedOccs) throws Exception {
    final String TcMethodName = "askAppearanceLinks";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("askAppearanceLinks");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomline",bomline));
    tcreq.getArgs().add(TcUtility.createArg("relationType",relationType));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("linkedOccs"))
        {
          linkedOccs.value = TcUtility.queryArg((ArgType)respArgs.get(ii), linkedOccs.value);
        }
      }
    }
  }

  public void askAppearancePathNode(byte[] bomline, uidValue_u contextLine, uidValue_uHolder apn, uidValue_uHolder apnType) throws Exception {
    final String TcMethodName = "askAppearancePathNode";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("askAppearancePathNode");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomline",bomline));
    tcreq.getArgs().add(TcUtility.createArg("contextLine",contextLine));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("apn"))
        {
          apn.value = TcUtility.queryArg((ArgType)respArgs.get(ii), apn.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("apnType"))
        {
          apnType.value = TcUtility.queryArg((ArgType)respArgs.get(ii), apnType.value);
        }
      }
    }
  }

  public void getNewSequenceNumber(byte[] bomline, uidValue_u item, stringValue_uHolder seqNo) throws Exception {
    final String TcMethodName = "getNewSequenceNumber";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("getNewSequenceNumber");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomline",bomline));
    tcreq.getArgs().add(TcUtility.createArg("item",item));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("seqNo"))
        {
          seqNo.value = TcUtility.queryArg((ArgType)respArgs.get(ii), seqNo.value);
        }
      }
    }
  }

  public void cut(byte[] bomline) throws Exception {
    final String TcMethodName = "cut";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("cut");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomline",bomline));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
      }
    }
  }

  public void bomCompare(byte[] bomLine1, byte[] bomLine2, short mode, short desiredOutputMode, BooleanHolder anyDiffs) throws Exception {
    final String TcMethodName = "bomCompare";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("bomCompare");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomLine1",bomLine1));
    tcreq.getArgs().add(TcUtility.createArg("bomLine2",bomLine2));
    tcreq.getArgs().add(TcUtility.createArg("mode",mode));
    tcreq.getArgs().add(TcUtility.createArg("desiredOutputMode",desiredOutputMode));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("anyDiffs"))
        {
          anyDiffs.value = TcUtility.queryArg((ArgType)respArgs.get(ii), anyDiffs.value);
        }
      }
    }
  }

  public void bomCompareModes(boolean visibleOnly, stringSeq_tHolder modes, stringSeq_tHolder displayNames) throws Exception {
    final String TcMethodName = "bomCompareModes";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("bomCompareModes");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("visibleOnly",visibleOnly));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("modes"))
        {
          modes.value = TcUtility.queryArg((ArgType)respArgs.get(ii), modes.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("displayNames"))
        {
          displayNames.value = TcUtility.queryArg((ArgType)respArgs.get(ii), displayNames.value);
        }
      }
    }
  }

  public void bomCompareExecute(byte[] bomLine1, byte[] bomLine2, stringValue_u modeName, short desiredOutputMode, BooleanHolder anyDiffs) throws Exception {
    final String TcMethodName = "bomCompareExecute";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("bomCompareExecute");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomLine1",bomLine1));
    tcreq.getArgs().add(TcUtility.createArg("bomLine2",bomLine2));
    tcreq.getArgs().add(TcUtility.createArg("modeName",modeName));
    tcreq.getArgs().add(TcUtility.createArg("desiredOutputMode",desiredOutputMode));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("anyDiffs"))
        {
          anyDiffs.value = TcUtility.queryArg((ArgType)respArgs.get(ii), anyDiffs.value);
        }
      }
    }
  }

  public void bomCompareReport(byte[] bomLine, stringSeq_tHolder reportLines, uidSeq_tHolder reportItems) throws Exception {
    final String TcMethodName = "bomCompareReport";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("bomCompareReport");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomLine",bomLine));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("reportLines"))
        {
          reportLines.value = TcUtility.queryArg((ArgType)respArgs.get(ii), reportLines.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("reportItems"))
        {
          reportItems.value = TcUtility.queryArg((ArgType)respArgs.get(ii), reportItems.value);
        }
      }
    }
  }

  public void bomCompareListBomlines(byte[] cmpItem, uidSeq_tHolder lists1, uidSeq_tHolder listTypes1, uidSeq_tHolder lists2, uidSeq_tHolder listTypes2) throws Exception {
    final String TcMethodName = "bomCompareListBomlines";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("bomCompareListBomlines");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("cmpItem",cmpItem));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("lists1"))
        {
          lists1.value = TcUtility.queryArg((ArgType)respArgs.get(ii), lists1.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("listTypes1"))
        {
          listTypes1.value = TcUtility.queryArg((ArgType)respArgs.get(ii), listTypes1.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("lists2"))
        {
          lists2.value = TcUtility.queryArg((ArgType)respArgs.get(ii), lists2.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("listTypes2"))
        {
          listTypes2.value = TcUtility.queryArg((ArgType)respArgs.get(ii), listTypes2.value);
        }
      }
    }
  }

  public void bomCompareClear(byte[] bomLine) throws Exception {
    final String TcMethodName = "bomCompareClear";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("bomCompareClear");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomLine",bomLine));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
      }
    }
  }

  public void bomCompareSetStopLine(byte[] bomLine) throws Exception {
    final String TcMethodName = "bomCompareSetStopLine";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("bomCompareSetStopLine");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomLine",bomLine));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
      }
    }
  }

  public void bomCompareSetStopLines(byte[] rootLine, byte[][] bomLines) throws Exception {
    final String TcMethodName = "bomCompareSetStopLines";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("bomCompareSetStopLines");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("rootLine",rootLine));
    tcreq.getArgs().add(TcUtility.createArg("bomLines",bomLines));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
      }
    }
  }

  public void bomCompareClearStopLine(byte[] bomLine) throws Exception {
    final String TcMethodName = "bomCompareClearStopLine";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("bomCompareClearStopLine");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomLine",bomLine));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
      }
    }
  }

  public void bomCompareListDiffs(byte[] bomLine, uidSeq_tHolder diffLines, uidSeq_tHolder diffLineTypes, longSeq_tHolder diffFlags) throws Exception {
    final String TcMethodName = "bomCompareListDiffs";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("bomCompareListDiffs");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomLine",bomLine));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("diffLines"))
        {
          diffLines.value = TcUtility.queryArg((ArgType)respArgs.get(ii), diffLines.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("diffLineTypes"))
        {
          diffLineTypes.value = TcUtility.queryArg((ArgType)respArgs.get(ii), diffLineTypes.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("diffFlags"))
        {
          diffFlags.value = TcUtility.queryArg((ArgType)respArgs.get(ii), diffFlags.value);
        }
      }
    }
  }

  public void listSubstitutes(byte[] bomLine, uidSeq_tHolder substitutes) throws Exception {
    final String TcMethodName = "listSubstitutes";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("listSubstitutes");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomLine",bomLine));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("substitutes"))
        {
          substitutes.value = TcUtility.queryArg((ArgType)respArgs.get(ii), substitutes.value);
        }
      }
    }
  }

  public void getRemoteChildren(byte[] bomLine, uidSeq_tHolder remotes) throws Exception {
    final String TcMethodName = "getRemoteChildren";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("getRemoteChildren");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomLine",bomLine));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("remotes"))
        {
          remotes.value = TcUtility.queryArg((ArgType)respArgs.get(ii), remotes.value);
        }
      }
    }
  }

  public void askRemoteObjectPublicationRecords(byte[][] bomLines, uidSeq_tHolder pubRecs, uidSeq_tHolder pubRecTypes) throws Exception {
    final String TcMethodName = "askRemoteObjectPublicationRecords";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("askRemoteObjectPublicationRecords");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomLines",bomLines));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("pubRecs"))
        {
          pubRecs.value = TcUtility.queryArg((ArgType)respArgs.get(ii), pubRecs.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("pubRecTypes"))
        {
          pubRecTypes.value = TcUtility.queryArg((ArgType)respArgs.get(ii), pubRecTypes.value);
        }
      }
    }
  }

  public void preferSubstitute(byte[] bomLine, BooleanHolder isTemporary) throws Exception {
    final String TcMethodName = "preferSubstitute";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("preferSubstitute");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomLine",bomLine));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("isTemporary"))
        {
          isTemporary.value = TcUtility.queryArg((ArgType)respArgs.get(ii), isTemporary.value);
        }
      }
    }
  }

  public void isReplaceable(byte[] bomLine, BooleanHolder verdict) throws Exception {
    final String TcMethodName = "isReplaceable";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("isReplaceable");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomLine",bomLine));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("verdict"))
        {
          verdict.value = TcUtility.queryArg((ArgType)respArgs.get(ii), verdict.value);
        }
      }
    }
  }

  public void setPrecision(byte[] bomLine, boolean whetherPrecise) throws Exception {
    final String TcMethodName = "setPrecision";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("setPrecision");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomLine",bomLine));
    tcreq.getArgs().add(TcUtility.createArg("whetherPrecise",whetherPrecise));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
      }
    }
  }

  public void pack(byte[] bomLine) throws Exception {
    final String TcMethodName = "pack";
    System.out.println("pack pack pack pack");
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("pack");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomLine",bomLine));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
      }
    }
  }

  public void unpack(byte[] bomLine) throws Exception {
    final String TcMethodName = "unpack";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("unpack");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomLine",bomLine));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
      }
    }
  }

  public void isPacked(byte[] bomLine, BooleanHolder verdict) throws Exception {
    final String TcMethodName = "isPacked";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("isPacked");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomLine",bomLine));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("verdict"))
        {
          verdict.value = TcUtility.queryArg((ArgType)respArgs.get(ii), verdict.value);
        }
      }
    }
  }

  public void setOccurrenceEffectivity(byte[] bomLine, uidValue_u effectivityObject) throws Exception {
    final String TcMethodName = "setOccurrenceEffectivity";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("setOccurrenceEffectivity");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomLine",bomLine));
    tcreq.getArgs().add(TcUtility.createArg("effectivityObject",effectivityObject));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
      }
    }
  }

  public void askOccurrenceEffectivity(byte[] bomLine, byteSeq_tHolder effectivityObject, byteSeq_tHolder type) throws Exception {
    final String TcMethodName = "askOccurrenceEffectivity";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("askOccurrenceEffectivity");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomLine",bomLine));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("effectivityObject"))
        {
          effectivityObject.value = TcUtility.queryArg((ArgType)respArgs.get(ii), effectivityObject.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("type"))
        {
          type.value = TcUtility.queryArg((ArgType)respArgs.get(ii), type.value);
        }
      }
    }
  }

  public void loadAncestors(byte[] bomLine, boolean one_level) throws Exception {
    final String TcMethodName = "loadAncestors";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("loadAncestors");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomLine",bomLine));
    tcreq.getArgs().add(TcUtility.createArg("one_level",one_level));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
      }
    }
  }

  public void createAddIce(byte[] bomLine, byteSeq_tHolder newIce, byteSeq_tHolder newIceType) throws Exception {
    final String TcMethodName = "createAddIce";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("createAddIce");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomLine",bomLine));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("newIce"))
        {
          newIce.value = TcUtility.queryArg((ArgType)respArgs.get(ii), newIce.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("newIceType"))
        {
          newIceType.value = TcUtility.queryArg((ArgType)respArgs.get(ii), newIceType.value);
        }
      }
    }
  }

  public void createRemoveIce(byte[] bomLine, byteSeq_tHolder newIce, byteSeq_tHolder newIceType) throws Exception {
    final String TcMethodName = "createRemoveIce";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("createRemoveIce");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomLine",bomLine));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("newIce"))
        {
          newIce.value = TcUtility.queryArg((ArgType)respArgs.get(ii), newIce.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("newIceType"))
        {
          newIceType.value = TcUtility.queryArg((ArgType)respArgs.get(ii), newIceType.value);
        }
      }
    }
  }

  public void changeToReplace(byte[] deletedBOMLine, byte[] addedBOMLine) throws Exception {
    final String TcMethodName = "changeToReplace";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("changeToReplace");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("deletedBOMLine",deletedBOMLine));
    tcreq.getArgs().add(TcUtility.createArg("addedBOMLine",addedBOMLine));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
      }
    }
  }

  public void createVi(byte[] bomLine, boolean isLinkedToGenericComponent, stringValue_u itemId, stringValue_u itemName, stringValue_u typeName, stringValue_u revId, byteSeq_tHolder newItem, byteSeq_tHolder newRev) throws Exception {
    final String TcMethodName = "createVi";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("createVi");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomLine",bomLine));
    tcreq.getArgs().add(TcUtility.createArg("isLinkedToGenericComponent",isLinkedToGenericComponent));
    tcreq.getArgs().add(TcUtility.createArg("itemId",itemId));
    tcreq.getArgs().add(TcUtility.createArg("itemName",itemName));
    tcreq.getArgs().add(TcUtility.createArg("typeName",typeName));
    tcreq.getArgs().add(TcUtility.createArg("revId",revId));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("newItem"))
        {
          newItem.value = TcUtility.queryArg((ArgType)respArgs.get(ii), newItem.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("newRev"))
        {
          newRev.value = TcUtility.queryArg((ArgType)respArgs.get(ii), newRev.value);
        }
      }
    }
  }

  public void configureInVi(byte[] bomLine, byte[] variantItem) throws Exception {
    final String TcMethodName = "configureInVi";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("configureInVi");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomLine",bomLine));
    tcreq.getArgs().add(TcUtility.createArg("variantItem",variantItem));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
      }
    }
  }

  public void askCanSearchForViFromParent(byte[] bomLine, BooleanHolder reuseIdIsPossible) throws Exception {
    final String TcMethodName = "askCanSearchForViFromParent";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("askCanSearchForViFromParent");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomLine",bomLine));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("reuseIdIsPossible"))
        {
          reuseIdIsPossible.value = TcUtility.queryArg((ArgType)respArgs.get(ii), reuseIdIsPossible.value);
        }
      }
    }
  }

  public void mapViRequirementsFromParent(byte[] bomLine, byte[][] items, byte[][] options, int[] ops, int[] valueTypes, byte[][] lowValues, byte[][] highValues, uidSeqValue_uHolder itemsOut, stringSeqValue_uHolder optionsOut, longSeqValue_uHolder opsOut, longSeqValue_uHolder valueTypesOut, stringSeqValue_uHolder lowValuesOut, stringSeqValue_uHolder highValuesOut) throws Exception {
    final String TcMethodName = "mapViRequirementsFromParent";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("mapViRequirementsFromParent");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomLine",bomLine));
    tcreq.getArgs().add(TcUtility.createArg("items",items));
    tcreq.getArgs().add(TcUtility.createArg("options",options));
    tcreq.getArgs().add(TcUtility.createArg("ops",ops));
    tcreq.getArgs().add(TcUtility.createArg("valueTypes",valueTypes));
    tcreq.getArgs().add(TcUtility.createArg("lowValues",lowValues));
    tcreq.getArgs().add(TcUtility.createArg("highValues",highValues));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("itemsOut"))
        {
          itemsOut.value = TcUtility.queryArg((ArgType)respArgs.get(ii), itemsOut.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("optionsOut"))
        {
          optionsOut.value = TcUtility.queryArg((ArgType)respArgs.get(ii), optionsOut.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("opsOut"))
        {
          opsOut.value = TcUtility.queryArg((ArgType)respArgs.get(ii), opsOut.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("valueTypesOut"))
        {
          valueTypesOut.value = TcUtility.queryArg((ArgType)respArgs.get(ii), valueTypesOut.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("lowValuesOut"))
        {
          lowValuesOut.value = TcUtility.queryArg((ArgType)respArgs.get(ii), lowValuesOut.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("highValuesOut"))
        {
          highValuesOut.value = TcUtility.queryArg((ArgType)respArgs.get(ii), highValuesOut.value);
        }
      }
    }
  }

  public void askPropertyContext(byte[] bomLine, stringValue_u propertyName, byteSeq_tHolder contextLine) throws Exception {
    final String TcMethodName = "askPropertyContext";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("askPropertyContext");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomLine",bomLine));
    tcreq.getArgs().add(TcUtility.createArg("propertyName",propertyName));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("contextLine"))
        {
          contextLine.value = TcUtility.queryArg((ArgType)respArgs.get(ii), contextLine.value);
        }
      }
    }
  }

  public void askPropertyArrangementContext(byte[] bomLine, stringValue_u propertyName, byteSeq_tHolder contextLine, byteSeq_tHolder contextArrangement) throws Exception {
    final String TcMethodName = "askPropertyArrangementContext";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("askPropertyArrangementContext");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomLine",bomLine));
    tcreq.getArgs().add(TcUtility.createArg("propertyName",propertyName));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("contextLine"))
        {
          contextLine.value = TcUtility.queryArg((ArgType)respArgs.get(ii), contextLine.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("contextArrangement"))
        {
          contextArrangement.value = TcUtility.queryArg((ArgType)respArgs.get(ii), contextArrangement.value);
        }
      }
    }
  }

  public void deletePropertyContext(byte[] bomLine, stringValue_u propertyName, byte[] contextLine) throws Exception {
    final String TcMethodName = "deletePropertyContext";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("deletePropertyContext");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomLine",bomLine));
    tcreq.getArgs().add(TcUtility.createArg("propertyName",propertyName));
    tcreq.getArgs().add(TcUtility.createArg("contextLine",contextLine));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
      }
    }
  }

  public void getPropertyAndContext(byte[] bomLine, byte[] propertyName, stringValue_uHolder propertyUIFValue, byteSeq_tHolder contextLine) throws Exception {
    final String TcMethodName = "getPropertyAndContext";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("getPropertyAndContext");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomLine",bomLine));
    tcreq.getArgs().add(TcUtility.createArg("propertyName",propertyName));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("propertyUIFValue"))
        {
          propertyUIFValue.value = TcUtility.queryArg((ArgType)respArgs.get(ii), propertyUIFValue.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("contextLine"))
        {
          contextLine.value = TcUtility.queryArg((ArgType)respArgs.get(ii), contextLine.value);
        }
      }
    }
  }

  public void getPropertiesAndContexts(byte[] bomLine, byte[][] propertyNames, stringValueSeq_tHolder propertyUIFValues, uidSeq_tHolder contextLines) throws Exception {
    final String TcMethodName = "getPropertiesAndContexts";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("getPropertiesAndContexts");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomLine",bomLine));
    tcreq.getArgs().add(TcUtility.createArg("propertyNames",propertyNames));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("propertyUIFValues"))
        {
          propertyUIFValues.value = TcUtility.queryArg((ArgType)respArgs.get(ii), propertyUIFValues.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("contextLines"))
        {
          contextLines.value = TcUtility.queryArg((ArgType)respArgs.get(ii), contextLines.value);
        }
      }
    }
  }

  public void disconnect(byte[] lineUid) throws Exception {
    final String TcMethodName = "disconnect";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("disconnect");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("lineUid",lineUid));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
      }
    }
  }

  public void addToConnection(byte[] connLineUid, byte[][] lineUids) throws Exception {
    final String TcMethodName = "addToConnection";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("addToConnection");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("connLineUid",connLineUid));
    tcreq.getArgs().add(TcUtility.createArg("lineUids",lineUids));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
      }
    }
  }

  public void connectUsingGDELink(stringValue_u connName, stringValue_u connType, byte[][] lineUids, byteSeq_tHolder newConnLineUid, byteSeq_tHolder newConnLineType) throws Exception {
    final String TcMethodName = "connectUsingGDELink";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("connectUsingGDELink");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("connName",connName));
    tcreq.getArgs().add(TcUtility.createArg("connType",connType));
    tcreq.getArgs().add(TcUtility.createArg("lineUids",lineUids));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("newConnLineUid"))
        {
          newConnLineUid.value = TcUtility.queryArg((ArgType)respArgs.get(ii), newConnLineUid.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("newConnLineType"))
        {
          newConnLineType.value = TcUtility.queryArg((ArgType)respArgs.get(ii), newConnLineType.value);
        }
      }
    }
  }

  public void Connect(stringValue_u connId, stringValue_u connName, stringValue_u connType, stringValue_u connRev, byte[][] lineUids, byteSeq_tHolder newConnLineUid, byteSeq_tHolder newConnLineType) throws Exception {
    final String TcMethodName = "Connect";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("Connect");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("connId",connId));
    tcreq.getArgs().add(TcUtility.createArg("connName",connName));
    tcreq.getArgs().add(TcUtility.createArg("connType",connType));
    tcreq.getArgs().add(TcUtility.createArg("connRev",connRev));
    tcreq.getArgs().add(TcUtility.createArg("lineUids",lineUids));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("newConnLineUid"))
        {
          newConnLineUid.value = TcUtility.queryArg((ArgType)respArgs.get(ii), newConnLineUid.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("newConnLineType"))
        {
          newConnLineType.value = TcUtility.queryArg((ArgType)respArgs.get(ii), newConnLineType.value);
        }
      }
    }
  }

  public void removeFromConnection(byte[] connLineUid, byte[][] lineUids) throws Exception {
    final String TcMethodName = "removeFromConnection";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("removeFromConnection");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("connLineUid",connLineUid));
    tcreq.getArgs().add(TcUtility.createArg("lineUids",lineUids));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
      }
    }
  }

  public void listConnectedPorts(byte[] connLineUid, uidSeq_tHolder connectedLines, uidSeq_tHolder connectedLineTypes) throws Exception {
    final String TcMethodName = "listConnectedPorts";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("listConnectedPorts");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("connLineUid",connLineUid));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("connectedLines"))
        {
          connectedLines.value = TcUtility.queryArg((ArgType)respArgs.get(ii), connectedLines.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("connectedLineTypes"))
        {
          connectedLineTypes.value = TcUtility.queryArg((ArgType)respArgs.get(ii), connectedLineTypes.value);
        }
      }
    }
  }

  public void setSignalPvariable(byte[] signalLineUid, byte[] pvariableLineUid) throws Exception {
    final String TcMethodName = "setSignalPvariable";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("setSignalPvariable");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("signalLineUid",signalLineUid));
    tcreq.getArgs().add(TcUtility.createArg("pvariableLineUid",pvariableLineUid));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
      }
    }
  }

  public void unsetSignalPvariable(byte[] signalLineUid) throws Exception {
    final String TcMethodName = "unsetSignalPvariable";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("unsetSignalPvariable");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("signalLineUid",signalLineUid));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
      }
    }
  }

  public void askSignalPvariable(byte[] signalLineUid, byteSeq_tHolder pvariableLineUid, byteSeq_tHolder pvariableTypeUid) throws Exception {
    final String TcMethodName = "askSignalPvariable";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("askSignalPvariable");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("signalLineUid",signalLineUid));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("pvariableLineUid"))
        {
          pvariableLineUid.value = TcUtility.queryArg((ArgType)respArgs.get(ii), pvariableLineUid.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("pvariableTypeUid"))
        {
          pvariableTypeUid.value = TcUtility.queryArg((ArgType)respArgs.get(ii), pvariableTypeUid.value);
        }
      }
    }
  }

  public void askSignalPvariables(byte[] signalLineUid, uidSeq_tHolder pvariableLines, uidSeq_tHolder pvariableLinesTypes) throws Exception {
    final String TcMethodName = "askSignalPvariables";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("askSignalPvariables");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("signalLineUid",signalLineUid));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("pvariableLines"))
        {
          pvariableLines.value = TcUtility.queryArg((ArgType)respArgs.get(ii), pvariableLines.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("pvariableLinesTypes"))
        {
          pvariableLinesTypes.value = TcUtility.queryArg((ArgType)respArgs.get(ii), pvariableLinesTypes.value);
        }
      }
    }
  }

  public void askSignalsOfPvariable(byte[] pvariableLineUid, uidSeq_tHolder signalLines, uidSeq_tHolder signalLinesTypes) throws Exception {
    final String TcMethodName = "askSignalsOfPvariable";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("askSignalsOfPvariable");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("pvariableLineUid",pvariableLineUid));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("signalLines"))
        {
          signalLines.value = TcUtility.queryArg((ArgType)respArgs.get(ii), signalLines.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("signalLinesTypes"))
        {
          signalLinesTypes.value = TcUtility.queryArg((ArgType)respArgs.get(ii), signalLinesTypes.value);
        }
      }
    }
  }

  public void setAssociatedSystem(byte[] line1Uid, byte[] line2Uid, stringValue_u role) throws Exception {
    final String TcMethodName = "setAssociatedSystem";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("setAssociatedSystem");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("line1Uid",line1Uid));
    tcreq.getArgs().add(TcUtility.createArg("line2Uid",line2Uid));
    tcreq.getArgs().add(TcUtility.createArg("role",role));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
      }
    }
  }

  public void unsetAssociatedSystem(byte[] line1Uid, byte[] line2Uid) throws Exception {
    final String TcMethodName = "unsetAssociatedSystem";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("unsetAssociatedSystem");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("line1Uid",line1Uid));
    tcreq.getArgs().add(TcUtility.createArg("line2Uid",line2Uid));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
      }
    }
  }

  public void setAssociatedSystems(byte[] line1Uid, byte[][] linesUid, stringValue_u role) throws Exception {
    final String TcMethodName = "setAssociatedSystems";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("setAssociatedSystems");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("line1Uid",line1Uid));
    tcreq.getArgs().add(TcUtility.createArg("linesUid",linesUid));
    tcreq.getArgs().add(TcUtility.createArg("role",role));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
      }
    }
  }

  public void unsetAssociatedSystems(byte[] line1Uid, byte[][] linesUid, stringValue_u role) throws Exception {
    final String TcMethodName = "unsetAssociatedSystems";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("unsetAssociatedSystems");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("line1Uid",line1Uid));
    tcreq.getArgs().add(TcUtility.createArg("linesUid",linesUid));
    tcreq.getArgs().add(TcUtility.createArg("role",role));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
      }
    }
  }

  public void askAssociatedSystems(byte[] lineUid, uidSeq_tHolder associatedSystemLines, uidSeq_tHolder associatedSystemTypes) throws Exception {
    final String TcMethodName = "askAssociatedSystems";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("askAssociatedSystems");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("lineUid",lineUid));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("associatedSystemLines"))
        {
          associatedSystemLines.value = TcUtility.queryArg((ArgType)respArgs.get(ii), associatedSystemLines.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("associatedSystemTypes"))
        {
          associatedSystemTypes.value = TcUtility.queryArg((ArgType)respArgs.get(ii), associatedSystemTypes.value);
        }
      }
    }
  }

  public void askAssociatedSystemRole(byte[] line1Uid, byte[] line2Uid, stringValue_uHolder role) throws Exception {
    final String TcMethodName = "askAssociatedSystemRole";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("askAssociatedSystemRole");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("line1Uid",line1Uid));
    tcreq.getArgs().add(TcUtility.createArg("line2Uid",line2Uid));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("role"))
        {
          role.value = TcUtility.queryArg((ArgType)respArgs.get(ii), role.value);
        }
      }
    }
  }

  public void setRedundantSignals(byte[] signalLineUid, byte[][] redundantSignalLines) throws Exception {
    final String TcMethodName = "setRedundantSignals";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("setRedundantSignals");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("signalLineUid",signalLineUid));
    tcreq.getArgs().add(TcUtility.createArg("redundantSignalLines",redundantSignalLines));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
      }
    }
  }

  public void unsetRedundantSignals(byte[] signalLineUid, byte[][] redundantSignalLines) throws Exception {
    final String TcMethodName = "unsetRedundantSignals";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("unsetRedundantSignals");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("signalLineUid",signalLineUid));
    tcreq.getArgs().add(TcUtility.createArg("redundantSignalLines",redundantSignalLines));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
      }
    }
  }

  public void askRedundantSignals(byte[] signalLineUid, uidSeq_tHolder redundantSignalLines, uidSeq_tHolder redundantSignalTypes) throws Exception {
    final String TcMethodName = "askRedundantSignals";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("askRedundantSignals");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("signalLineUid",signalLineUid));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("redundantSignalLines"))
        {
          redundantSignalLines.value = TcUtility.queryArg((ArgType)respArgs.get(ii), redundantSignalLines.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("redundantSignalTypes"))
        {
          redundantSignalTypes.value = TcUtility.queryArg((ArgType)respArgs.get(ii), redundantSignalTypes.value);
        }
      }
    }
  }

  public void setSignalLineValue(byte[] signalLineUid, double signal_value) throws Exception {
    final String TcMethodName = "setSignalLineValue";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("setSignalLineValue");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("signalLineUid",signalLineUid));
    tcreq.getArgs().add(TcUtility.createArg("signal_value",signal_value));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
      }
    }
  }

  public void askSignalLineValue(byte[] signalLineUid, DoubleHolder signal_value) throws Exception {
    final String TcMethodName = "askSignalLineValue";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("askSignalLineValue");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("signalLineUid",signalLineUid));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("signal_value"))
        {
          signal_value.value = TcUtility.queryArg((ArgType)respArgs.get(ii), signal_value.value);
        }
      }
    }
  }

  public void askSourcesOfDevice(byte[] lineUid, uidSeq_tHolder sourceLines, uidSeq_tHolder sourceTypes) throws Exception {
    final String TcMethodName = "askSourcesOfDevice";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("askSourcesOfDevice");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("lineUid",lineUid));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("sourceLines"))
        {
          sourceLines.value = TcUtility.queryArg((ArgType)respArgs.get(ii), sourceLines.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("sourceTypes"))
        {
          sourceTypes.value = TcUtility.queryArg((ArgType)respArgs.get(ii), sourceTypes.value);
        }
      }
    }
  }

  public void askTargetsOfDevice(byte[] lineUid, uidSeq_tHolder targetLines, uidSeq_tHolder targetTypes) throws Exception {
    final String TcMethodName = "askTargetsOfDevice";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("askTargetsOfDevice");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("lineUid",lineUid));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("targetLines"))
        {
          targetLines.value = TcUtility.queryArg((ArgType)respArgs.get(ii), targetLines.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("targetTypes"))
        {
          targetTypes.value = TcUtility.queryArg((ArgType)respArgs.get(ii), targetTypes.value);
        }
      }
    }
  }

  public void askSourcesOfSignal(byte[] lineUid, uidSeq_tHolder sourceLines, uidSeq_tHolder sourceTypes) throws Exception {
    final String TcMethodName = "askSourcesOfSignal";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("askSourcesOfSignal");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("lineUid",lineUid));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("sourceLines"))
        {
          sourceLines.value = TcUtility.queryArg((ArgType)respArgs.get(ii), sourceLines.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("sourceTypes"))
        {
          sourceTypes.value = TcUtility.queryArg((ArgType)respArgs.get(ii), sourceTypes.value);
        }
      }
    }
  }

  public void askTargetsOfSignal(byte[] lineUid, uidSeq_tHolder targetLines, uidSeq_tHolder targetTypes) throws Exception {
    final String TcMethodName = "askTargetsOfSignal";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("askTargetsOfSignal");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("lineUid",lineUid));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("targetLines"))
        {
          targetLines.value = TcUtility.queryArg((ArgType)respArgs.get(ii), targetLines.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("targetTypes"))
        {
          targetTypes.value = TcUtility.queryArg((ArgType)respArgs.get(ii), targetTypes.value);
        }
      }
    }
  }

  public void askTransmittersOfSignal(byte[] lineUid, uidSeq_tHolder txmttrLines, uidSeq_tHolder txmttrTypes) throws Exception {
    final String TcMethodName = "askTransmittersOfSignal";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("askTransmittersOfSignal");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("lineUid",lineUid));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("txmttrLines"))
        {
          txmttrLines.value = TcUtility.queryArg((ArgType)respArgs.get(ii), txmttrLines.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("txmttrTypes"))
        {
          txmttrTypes.value = TcUtility.queryArg((ArgType)respArgs.get(ii), txmttrTypes.value);
        }
      }
    }
  }

  public void askTransmittedSignalsOfDevice(byte[] lineUid, uidSeq_tHolder txmttdLines, uidSeq_tHolder txmttdTypes) throws Exception {
    final String TcMethodName = "askTransmittedSignalsOfDevice";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("askTransmittedSignalsOfDevice");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("lineUid",lineUid));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("txmttdLines"))
        {
          txmttdLines.value = TcUtility.queryArg((ArgType)respArgs.get(ii), txmttdLines.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("txmttdTypes"))
        {
          txmttdTypes.value = TcUtility.queryArg((ArgType)respArgs.get(ii), txmttdTypes.value);
        }
      }
    }
  }

  public void askReceivedSignalsOfDevice(byte[] lineUid, uidSeq_tHolder receivedLines, uidSeq_tHolder receivedTypes) throws Exception {
    final String TcMethodName = "askReceivedSignalsOfDevice";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("askReceivedSignalsOfDevice");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("lineUid",lineUid));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("receivedLines"))
        {
          receivedLines.value = TcUtility.queryArg((ArgType)respArgs.get(ii), receivedLines.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("receivedTypes"))
        {
          receivedTypes.value = TcUtility.queryArg((ArgType)respArgs.get(ii), receivedTypes.value);
        }
      }
    }
  }

  public void removeImplementedBy(byte[] primaryLineUid, byte[][] lineUids) throws Exception {
    final String TcMethodName = "removeImplementedBy";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("removeImplementedBy");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("primaryLineUid",primaryLineUid));
    tcreq.getArgs().add(TcUtility.createArg("lineUids",lineUids));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
      }
    }
  }

  public void removeRealizedBy(byte[] primaryLineUid, byte[][] lineUids) throws Exception {
    final String TcMethodName = "removeRealizedBy";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("removeRealizedBy");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("primaryLineUid",primaryLineUid));
    tcreq.getArgs().add(TcUtility.createArg("lineUids",lineUids));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
      }
    }
  }

  public void setImplementedBy(byte[] primaryLineUid, byte[] secondaryLineUid) throws Exception {
    final String TcMethodName = "setImplementedBy";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("setImplementedBy");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("primaryLineUid",primaryLineUid));
    tcreq.getArgs().add(TcUtility.createArg("secondaryLineUid",secondaryLineUid));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
      }
    }
  }

  public void setRealizedBy(byte[] primaryLineUid, byte[] secondaryLineUid) throws Exception {
    final String TcMethodName = "setRealizedBy";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("setRealizedBy");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("primaryLineUid",primaryLineUid));
    tcreq.getArgs().add(TcUtility.createArg("secondaryLineUid",secondaryLineUid));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
      }
    }
  }

  public void getImplementedBy(byte[] primaryLineUid, uidSeq_tHolder implementedByLines, uidSeq_tHolder implementedByLineTypes) throws Exception {
    final String TcMethodName = "getImplementedBy";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("getImplementedBy");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("primaryLineUid",primaryLineUid));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("implementedByLines"))
        {
          implementedByLines.value = TcUtility.queryArg((ArgType)respArgs.get(ii), implementedByLines.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("implementedByLineTypes"))
        {
          implementedByLineTypes.value = TcUtility.queryArg((ArgType)respArgs.get(ii), implementedByLineTypes.value);
        }
      }
    }
  }

  public void getRealizedBy(byte[] primaryLineUid, uidSeq_tHolder realizedByLines, uidSeq_tHolder realizedByLineTypes) throws Exception {
    final String TcMethodName = "getRealizedBy";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("getRealizedBy");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("primaryLineUid",primaryLineUid));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("realizedByLines"))
        {
          realizedByLines.value = TcUtility.queryArg((ArgType)respArgs.get(ii), realizedByLines.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("realizedByLineTypes"))
        {
          realizedByLineTypes.value = TcUtility.queryArg((ArgType)respArgs.get(ii), realizedByLineTypes.value);
        }
      }
    }
  }

  public void getImplementingLines(byte[] secondaryLineUid, uidSeq_tHolder implementingLines, uidSeq_tHolder implementingLineTypes) throws Exception {
    final String TcMethodName = "getImplementingLines";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("getImplementingLines");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("secondaryLineUid",secondaryLineUid));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("implementingLines"))
        {
          implementingLines.value = TcUtility.queryArg((ArgType)respArgs.get(ii), implementingLines.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("implementingLineTypes"))
        {
          implementingLineTypes.value = TcUtility.queryArg((ArgType)respArgs.get(ii), implementingLineTypes.value);
        }
      }
    }
  }

  public void getRealizingLines(byte[] secondaryLineUid, uidSeq_tHolder realizingLines, uidSeq_tHolder realizingLineTypes) throws Exception {
    final String TcMethodName = "getRealizingLines";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("getRealizingLines");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("secondaryLineUid",secondaryLineUid));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("realizingLines"))
        {
          realizingLines.value = TcUtility.queryArg((ArgType)respArgs.get(ii), realizingLines.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("realizingLineTypes"))
        {
          realizingLineTypes.value = TcUtility.queryArg((ArgType)respArgs.get(ii), realizingLineTypes.value);
        }
      }
    }
  }

  public void removeBOMLineIncrementalChanges(byte[] lineUid, byte[][] iceUids) throws Exception {
    final String TcMethodName = "removeBOMLineIncrementalChanges";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("removeBOMLineIncrementalChanges");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("lineUid",lineUid));
    tcreq.getArgs().add(TcUtility.createArg("iceUids",iceUids));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
      }
    }
  }

  public void removeAbsOccDataIncrementalChanges(byte[] lineUid, byte[][] iceUids) throws Exception {
    final String TcMethodName = "removeAbsOccDataIncrementalChanges";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("removeAbsOccDataIncrementalChanges");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("lineUid",lineUid));
    tcreq.getArgs().add(TcUtility.createArg("iceUids",iceUids));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
      }
    }
  }

  public void addRelatedSubstitutes(byte[][] subItems, byte[][] occurrences) throws Exception {
    final String TcMethodName = "addRelatedSubstitutes";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("addRelatedSubstitutes");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("subItems",subItems));
    tcreq.getArgs().add(TcUtility.createArg("occurrences",occurrences));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
      }
    }
  }

  public void removeRelatedSubstitutes(byte[][] subItems, byte[][] occurrences) throws Exception {
    final String TcMethodName = "removeRelatedSubstitutes";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("removeRelatedSubstitutes");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("subItems",subItems));
    tcreq.getArgs().add(TcUtility.createArg("occurrences",occurrences));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
      }
    }
  }

  public void listRelatedSubstitutes(byte[][] bomLines, uidSeqValue_uHolder relatedOccurrences, uidSeqValue_uHolder relatedOccTypes, uidSeqValue_uHolder relatedItems, uidSeqValue_uHolder relatedItemTypes) throws Exception {
    final String TcMethodName = "listRelatedSubstitutes";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("listRelatedSubstitutes");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomLines",bomLines));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("relatedOccurrences"))
        {
          relatedOccurrences.value = TcUtility.queryArg((ArgType)respArgs.get(ii), relatedOccurrences.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("relatedOccTypes"))
        {
          relatedOccTypes.value = TcUtility.queryArg((ArgType)respArgs.get(ii), relatedOccTypes.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("relatedItems"))
        {
          relatedItems.value = TcUtility.queryArg((ArgType)respArgs.get(ii), relatedItems.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("relatedItemTypes"))
        {
          relatedItemTypes.value = TcUtility.queryArg((ArgType)respArgs.get(ii), relatedItemTypes.value);
        }
      }
    }
  }

  public void getAllAbsOccData(byte[] lineUid, uidSeq_tHolder absOccData, uidValueSeq_tHolder absOccIces, uidValueSeq_tHolder qualBvrs, stringValueSeq_tHolder propNames, stringValueSeq_tHolder propValues) throws Exception {
    final String TcMethodName = "getAllAbsOccData";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("getAllAbsOccData");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("lineUid",lineUid));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("absOccData"))
        {
          absOccData.value = TcUtility.queryArg((ArgType)respArgs.get(ii), absOccData.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("absOccIces"))
        {
          absOccIces.value = TcUtility.queryArg((ArgType)respArgs.get(ii), absOccIces.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("qualBvrs"))
        {
          qualBvrs.value = TcUtility.queryArg((ArgType)respArgs.get(ii), qualBvrs.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("propNames"))
        {
          propNames.value = TcUtility.queryArg((ArgType)respArgs.get(ii), propNames.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("propValues"))
        {
          propValues.value = TcUtility.queryArg((ArgType)respArgs.get(ii), propValues.value);
        }
      }
    }
  }

  public void addOptional(byte[] bomline, uidValue_u item, uidValue_u rev, uidValue_u bv) throws Exception {
    final String TcMethodName = "addOptional";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("addOptional");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomline",bomline));
    tcreq.getArgs().add(TcUtility.createArg("item",item));
    tcreq.getArgs().add(TcUtility.createArg("rev",rev));
    tcreq.getArgs().add(TcUtility.createArg("bv",bv));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
      }
    }
  }

  public void removeOptional(byte[] bomline, uidValue_u item, uidValue_u rev, uidValue_u bv) throws Exception {
    final String TcMethodName = "removeOptional";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("removeOptional");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomline",bomline));
    tcreq.getArgs().add(TcUtility.createArg("item",item));
    tcreq.getArgs().add(TcUtility.createArg("rev",rev));
    tcreq.getArgs().add(TcUtility.createArg("bv",bv));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
      }
    }
  }

  public void getOptionals(byte[] bomline, uidSeqValue_uHolder items, uidSeqValue_uHolder itemTypes) throws Exception {
    final String TcMethodName = "getOptionals";
    
//Create TcRequest object
    TcRequest tcreq = objFactory.createTcRequest();
    tcreq.setService(service_name());
    tcreq.setMethod("getOptionals");
    
//Populate TcRequest object with input arguments one by one
    tcreq.getArgs().add(TcUtility.createArg("tccorba_objid", object_id().getBytes()));
    tcreq.getArgs().add(TcUtility.createArg("bomline",bomline));
    
//Get SOA connection and use SOA RestSender to submit the request
    Connection soaConnection = client_session.getSoaConnection();
    ResponseExceptionHandler soaHandler = (ResponseExceptionHandler)soaConnection.getExceptionHandler();
    
//This would suppress SOA error dialogue for ICCT calls
    soaHandler.setup();
    RestSender restSender =  soaConnection.getSender();
    Object responseObject = null;
    try
    {
      responseObject = restSender.invoke(service_name(), TcMethodName, tcreq,"com.ugsplm.tc.codegen.parser.newreqresp", "com.ugsplm.tc.codegen.parser.newreqresp");
    }
    catch(SoaRuntimeException e)
    {
      int[] codes = e.errorCodes;
      int errorSize = codes.length;
      throw new ICCTException( errorSize, e.errorSeverities, codes, e.errorMessages );
    }
    TcResponse resp = (TcResponse)responseObject;
    
//Retrieve Arg objects
    java.util.List respArgs = null;
    TcCorbaResponseType corbaResp = resp.getTcCorbaResponse();
    TcErrorType tcerrors = resp.getTcError();
    if(corbaResp != null) respArgs = corbaResp.getArgs();
    else if(tcerrors != null && tcerrors.getTcErrorValues()!= null ) TcUtility.throwExeption(client_session,tcerrors.getTcErrorValues());
    
//Retrieve return value and output arguments one by one
    if(respArgs != null)
    {
      for(int ii = 0; ii<respArgs.size(); ii++)
      {
        //retrieve output arguments
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("items"))
        {
          items.value = TcUtility.queryArg((ArgType)respArgs.get(ii), items.value);
        }
        if(respArgs.get(ii) != null && ((ArgType)respArgs.get(ii)).getName().equals("itemTypes"))
        {
          itemTypes.value = TcUtility.queryArg((ArgType)respArgs.get(ii), itemTypes.value);
        }
      }
    }
  }

}
